package com.alpaak.common.utils;

import com.alpaak.common.utils.log.Log4jUtil;
import net.sf.json.JSONObject;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

/**
 * <p>标题: 关于字典和参数类型数据的缓冲加载基类</p>
 * <p>说明: 所有数据通过大类type、编码code、名称(或参数值)name、备注remark进行标识。</p>
 * <p>         提供数据同步的基本方法，以及获取大类数据、或生成下拉框的基础方法</p>
 * <p>版权: Copyright 2008 .zhang qin bao.</p>
 * <p>时间: Feb 3, 2008 10:44:06 AM</p>
 *
 * @author zqb
 * @version 2.0
 */
public abstract class OptionDictSupport {
	//WebService接口服务
	public static String WEBSERVICE_URL = "";
	
	//可以显示的字典列表map<type,map<code.name>>
	private static TreeMap<String, TreeMap<String, String>> nameMap = new TreeMap<String, TreeMap<String, String>>();
	
	//字典默认选项定义，没有则代表无默认值
    private static TreeMap<String, String> defaultMap = new TreeMap<String, String>();
    
    //字典备注列表map<type,map<code.remark>>
    private static TreeMap<String, TreeMap<String, String>> remarkMap = new TreeMap<String, TreeMap<String, String>>();
    
    //不可以显示的字典列表
    private static TreeMap<String, TreeMap<String, String>> noViewMap = new TreeMap<String, TreeMap<String, String>>();
	
    //不同语言的字符集
	//private static String language[] = Language.getLanguage("OptionDict");
	
    public static void init() {
    }
    public static void destroy(){
    	nameMap.clear();
    	defaultMap.clear();
    	remarkMap.clear();
    	noViewMap.clear();
    }
    /**
     * 将给定的字典内容插入到字典列表中
     * @param type          大类标志
     * @param code          某个大类下选项编码
     * @param name          选项名称
     * @param selected      当前的选项是否是此大类下的默认选中项目
     * @param remark		备注
     * @param view			是否显示在下拉列表中
     */
    public static synchronized void add(String type,String code,String name,boolean selected,String remark,boolean view){
    	
    	if(type==null||type.equals("")||code==null||code.equals(""))
    		return;
    	
    	if(name==null||name.equals("null"))
    		name = code;
    	if(view){
        	//name
            if (nameMap.get(type) == null) {
                TreeMap<String, String> temp = new TreeMap<String, String>(aa10TreeMapComparator);             
                temp.put(code, name);
                nameMap.put(type, temp);
            } else {
                TreeMap<String, String> temp = (TreeMap<String, String>) nameMap.get(type);
                temp.put(code,name);
            }
            //删除不可显示数据
            if(noViewMap.get(type)!=null){
                TreeMap<String, String> temp = (TreeMap<String, String>) noViewMap.get(type);
                temp.remove(code);
            }
    	}else{
        	//name
            if (noViewMap.get(type) == null) {
                TreeMap<String, String> temp = new TreeMap<String, String>();
                temp.put(code, name);
                noViewMap.put(type, temp);
            } else {
                TreeMap<String, String> temp = (TreeMap<String, String>) noViewMap.get(type);
                temp.put(code,name);
            }
            //删除可以显示数据
            if(nameMap.get(type)!=null){
                TreeMap<String, String> temp = (TreeMap<String, String>) nameMap.get(type);
                temp.remove(code);
            }
    	}
        //remark
        if (remarkMap.get(type) == null) {
            TreeMap<String, String> temp = new TreeMap<String, String>();
            temp.put(code, remark);
            remarkMap.put(type, temp);
        } else {
            TreeMap<String, String> temp = (TreeMap<String, String>) remarkMap.get(type);
            temp.put(code,remark);
        }
        
        if(selected&&view){
            defaultMap.put(type, code);
        }
    }
    /**
     * 将给定的字典内容修改到字典列表中
     * @param type          大类标志
     * @param code          某个大类下选项编码
     * @param name          选项名称
     * @param selected      当前的选项是否是此大类下的默认选中项目
     */
    public final static synchronized void update(String type,String code,String name,boolean selected,String remark,boolean view){
        add(type,code,name,selected,remark,view);
    }
    /**
     * 删除指定代码类表下某个具体选项，如果选项编号为空，则删除整个代码类
     * @param type          大类标志
     * @param code          某个大类下选项编码
     */
    public final static synchronized void delete(String type, String code) {
        if((code==null)||("".equals(code))){
        	nameMap.remove(type);
        	remarkMap.remove(type);
        	noViewMap.remove(type);
            defaultMap.remove(type);
        }else if (type != null && !type.equals("")) {
            TreeMap temp1 = getNameMap(type);
            if(temp1!=null){
            	temp1.remove(code);
                defaultMap.remove(type);
            }
            TreeMap temp2= getRemarkMap(type);
            if(temp2!=null){
            	temp2.remove(code);
            }
            TreeMap temp3= getNoViewMap(type);
            if(temp3!=null){
            	temp3.remove(code);
            }
        }
    }
	/**
	 * 与缓存中的参数进行比较,是否存在该值，本方法通常用于判断指定值是否满足参数表AA01。
	 * 例如isExistParam("EMUR","admin","88881")表示判断用户88881是否是默认的系统管理员
	 * @param aae140 系统类别
	 * @param aaa003 参数类别
	 * @param par 需要对比的参数
	 * @return boolean
	 */
	public static boolean isExistParam(String aae140, String aaa003, String par) {
		String param =  getCodeName(aae140,aaa003);
		if(param!=null){
			for (String a : param.split(",")) {
				if (a.equals(par)) {
					return true;
				}
			}
		}
		return false;
	}
    /**
     * 获取所有可以显示的代码字典列表
     * @return Returns the (type,map(code,name))
     */
    public final static TreeMap<String, TreeMap<String, String>> getNameMap() {
        return nameMap;
    }
    
    
    /**
     * 获取某种类型下可以显示的代码字典列表
     * @param type
     * @return Returns the map(code,name)
     */
    public final static TreeMap<String, String> getNameMap(String type) {
        return (TreeMap<String, String>)nameMap.get(type);
    }
    
    
    /**
     * 返回所有类别的代码字典的默认值
     * @return Returns the (type,defaultCode).
     */
    public final static TreeMap<String, String> getDefaultMap() {
        return defaultMap;
    }
    /**
     * 返回某种类别下的代码默认值
     * @param type
     * @return Returns the defaultCode.
     */
    public final static String getDefaultMap(String type) {
        return (String)defaultMap.get(type);
    }
    /**
     * 根据字典大类编码和小类编码获取字典项目名称（小类）
     * @param type 大类编码
     * @param code 小类编码
     * @return Returns the name
     */
    public final static String getCodeName(String type, String code) {
    	return getCodeName(type,code,null);
    }
    
    /**
     * 根据参数大类编码和小类编码获取参数值。
     * 当参数中存在要查询的内容时，默认值无效，当字典中不存在查询的内容时，返回默认值。
     * @param type 大类编码
     * @param code 小类编码
     * @param defaultCode 默认值
     * @return Returns the name
     */
    public final static String getCodeName(String type, String code, String defaultCode) {
        if (type == null || type.equals("")||code==null||code.equals("")){
            return "";
        }else{
            // 获取指定大类type的数据
        	String name = null;
        	String[] codeArr = code.split(",");
            TreeMap temp1 = getNameMap(type);
            if(temp1!=null){
            	//如果某个字段是可以多个标准项选择的，则进行分解，分隔符默认  ","     20120712-xwg       	
        		for(int i=0;i<codeArr.length;i++){
            		if(name==null){
            			name = (String)temp1.get(codeArr[i]);
            		}else{
            			name += "," + (String)temp1.get(codeArr[i]);
            		}
        		}            	
            }
            if(name==null||name.equalsIgnoreCase("")){
            	TreeMap temp2 = getNoViewMap(type);
            	if(temp2!=null){
            		for(int i=0;i<codeArr.length;i++){
	            		if(name==null){
	            			name = (String)temp2.get(codeArr[i]);
	            		}else{
	            			name += "," + (String)temp2.get(codeArr[i]);
	            		}
            		}                
            	}
            }
            if(name==null||name.equals("")){
            	if(defaultCode!=null)
            		return defaultCode;
            	else
            		return "";
            }else
            	return name;
        }
    }
    /**
     * 根据字典大类编码和小类编码获取小类备注
     * @param type 大类编号
     * @param code 小类编号
     * @return Returns the remark(备注)
     */
    public final static String getCodeRemark(String type,String code){
        if (type == null || "".equals(type)||code==null&&"".equals(code)){
            return "";
        }else{
            TreeMap temp = getRemarkMap(type);
            if(temp!=null){
            	return (String)temp.get(code);
            }else{
            	return "";
            }
        }
    }
    
    /**
     * 获取所有代码字典列表的备注列表
     * @return Returns the (type,map(code,remark))
     */
    public final static TreeMap<String, TreeMap<String, String>> getRemarkMap(){
    	return remarkMap;
    }
    /**
     * 获取指定大类的代码字典列表的备注列表
     * @return Returns the map(code,remark)
     */
    public final static TreeMap<String, String> getRemarkMap(String type){
    	return (TreeMap<String, String>)remarkMap.get(type);
    }
    /**
     * 获取所有代码字典列表的不可以显示部分
     * @return Returns the (type,map(code,name))
     */
    public final static TreeMap<String, TreeMap<String, String>> getNoViewMap(){
    	return noViewMap;
    }
    /**
     * 获取指定大类的代码字典列表的不可以显示部分
     * @return Returns the map(code,name)
     */
    public final static TreeMap<String, String> getNoViewMap(String type){
    	return (TreeMap<String, String>)noViewMap.get(type);
    }
    
    /**
     * 获取某种类型下可以显示的代码字典列表
     * @param type
     * @return Returns the map(code,name)
     */
    public final static TreeMap<String, String> getNameMap(String type,String Filter) {
    	TreeMap<String, String> resultMap = new TreeMap<String, String>();
    	TreeMap<String, String> retMap = (TreeMap<String, String>)nameMap.get(type);
    	TreeMap<String, String> treemap_remark = (TreeMap<String, String>)remarkMap.get(type);
    	Iterator keyTree = retMap.keySet().iterator();
        Iterator valueTree = retMap.values().iterator();
        Iterator remarkTree = treemap_remark.values().iterator();
		//判断slglMap是否为空,如果不为空,则遍历Map,将Map键值分别对应存放进list中
        for (; keyTree.hasNext(); ) {
            String code = (String) keyTree.next();
            String name = (String) valueTree.next();
            String remark = (String) remarkTree.next();
            remark = (remark==null?"":remark);
            boolean isSet = false;
            if(Filter.split("=",-1).length==2){
            	String[] remarks = remark.split("\\|",-1);
            	String[] Filters = Filter.split("=",-1);
            	if(	remarks[Integer.parseInt(Filters[0])].equals(Filters[1])){
            		isSet = true;
            	}            	
            }else{
            	if(remark.equals(Filter)){
            		isSet = true;
            	}
            }
            if(isSet){
            	resultMap.put(code, name);            	
            }		            	
		}            	
        Log4jUtil.info("过滤="+Filter+" 结果="+retMap.toString());
        return resultMap;
    } 
	/**
	 * 从aa10表内存存储中，取得AAA105，AAA106，AAA107相关map
	 * @param type
	 * @param aaa10567Flag
	 * @return
	 */
	private static TreeMap<String, String> getAAA10567MapFromAA10(String type,String aaa10567Flag){
		TreeMap<String, String> map = null;
		aaa10567Flag = aaa10567Flag==null ? "" : aaa10567Flag.trim();
		if("AAA105".equalsIgnoreCase(aaa10567Flag.trim())){
			map = getNameMap(type+"_AAA105");
		}else if("AAA106".equalsIgnoreCase(aaa10567Flag.trim())){
			map = getNameMap(type+"_AAA106");
		}else if("AAA107".equalsIgnoreCase(aaa10567Flag.trim())){
			map = getNameMap(type+"_AAA107");
		}
		return map;
	}
	
	/**
	 * 从aa10表内存存储中，取得AAA105，AAA106，AAA107相关map
	 * 并根据AAA105、AAA106、AAA107指定的值对map过滤
	 * 最后将过滤后的map组成json格式返回
	 * @param type				字典大类
	 * @param aaa10567Flag		区分是AAA105、AAA106、AAA107
	 * @param aaa10567			AAA105或AAA106或AAA107的指定值
	 * @return
	 */
	private static String getAAA10567JsonMap(String type,String aaa10567Flag,String aaa10567){
		String jsonMap = "";
		JSONObject obj = new JSONObject();
		TreeMap<String, String> map = getAAA10567MapFromAA10(type, aaa10567Flag);
		if(map==null){
			map = new TreeMap<String, String>();
		}
		if(aaa10567!=null && !"".equals(aaa10567.trim())){
			TreeMap<String, String> map1 = new TreeMap<String, String>();
			for(String key : map.keySet()){
				String val = map.get(key);
				if(aaa10567.trim().equals(val)){
					map1.put(key, val);
				}
			}
			map = map1;
		}
		if(map!=null && map.size()>0){
			obj = JSONObject.fromObject(map,JsonUtil.getDefualtJsonConfig());
			jsonMap = obj.toString();
		}
		return jsonMap;
	}
	
	/**
	 * 从aa10表内存存储中，取得AAA105相关map
	 * 并根据AAA105指定的值对map过滤
	 * 最后将过滤后的map组成json格式返回
	 * @param type			字典大类
	 * @param aaa105		AAA105的指定值
	 * @return
	 */
	public static String getAAA105JsonMap(String type,String aaa105){
		return getAAA10567JsonMap(type, "AAA105", aaa105);
	}
	
	/**
	 * 将字典组成ComboBox  data
	 * 此下拉框的text是由aaa103(aae013)组成；名称(备注)
	 * @param nameMap
	 * @param remarkMap
	 * @param defaultCode
	 * @return
	 */
	public final static String getDefRmkComboBoxData(TreeMap<String,String> nameMap, TreeMap<String,String> remarkMap) {
		StringBuffer stringbuffer = new StringBuffer(512);

		if (nameMap == null)
			return stringbuffer.toString();
		if (remarkMap==null){//备注map
			remarkMap = new TreeMap<String, String>();
		}
		
		Iterator<Map.Entry<String, String>> iterator = nameMap.entrySet().iterator();

		stringbuffer.append("[");
        while (iterator.hasNext()) {  
            Map.Entry<String, String> entry = iterator.next();  
            stringbuffer.append("{");
            stringbuffer.append("value:\"");
            stringbuffer.append(entry.getKey());
            stringbuffer.append("\",");
            stringbuffer.append("text:\"");
            stringbuffer.append(entry.getValue()+"("+remarkMap.get(entry.getKey()).trim()+")");
            stringbuffer.append("\"}");
            if(iterator.hasNext()) {//最后一个元素
            	stringbuffer.append(",");
            }
        } 
		stringbuffer.append("]");
		return stringbuffer.toString();
	}
	/**
	 * 根据当前大类编号获取aaa103(aae013)即名称(备注)格式下拉列表，并用指定编码code数据作为默认选择。
	 * @param type
	 *            大类编号
	 * @param defaultCode
	 *            作为默认选项的项目编号(null为使用系统默认,""则强制无默认)
	 * @return 列表内数据格式为：编码code，名称name
	 */
	public final static String getDefRmkComboBoxData(String type) {
		if (type == null || type.equals("")) {
			return "";
		}
		// 获取当前大类type的字典数据
		TreeMap<String,String> namemap = getNameMap(type);
		
		// 获取当前大类type的备注数据
		TreeMap<String,String> remarkmap = getRemarkMap(type);
		return getDefRmkComboBoxData(namemap, remarkmap);
	}
	
	
    //更新字典内存中的相关信息
    public final static void addOrUpdatePara(String type,String code,String name){
    	OptionDictSupport.delete(type, code);
    	OptionDictSupport.add(type, code, name,false, null, true);
    }
    
    //treemap 排序规则改变，先按数字排，再按字母排
    private static final Comparator aa10TreeMapComparator = new Comparator(){
    	 public int compare(Object a, Object b){
         	try{              		
         		return Integer.valueOf(getSpeicalStr(a))-Integer.valueOf(getSpeicalStr(b));
         	}catch(Throwable e){
         		return String.valueOf(a).compareTo(String.valueOf(b));
         		/*if(a.toString().equals(b.toString())){
         			return 0;
         		}else{
         			return -1;
         		}*/
         	}
         }           
     };   
     
     private static final String getSpeicalStr(Object t){
    	 if(t!=null){
    		 if("甲".equals(t.toString())){
    			 return "0";
    		 }else if("乙".equals(t.toString())){
    			 return "1";
    		 }else if("丙".equals(t.toString())){
    			 return "2";
    		 }else if("丁".equals(t.toString())){
    			 return "3";    			 
    		 }else{
    			 return t.toString();
    		 }
    	 }else{
    		 return "";
    	 }    	
     }
}
 